C:/Projekte/RAIS/dataaccesslayertest/CommonClasses/FunctionRoleTest.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;
using RAIS.Common.UserManagement;
using RAIS.DataAccessLayer;

namespace RAIS.DataAccessLayerTest.CommonClasses
{
        [TestFixture]
        public class FunctionRoleTest
        {
                private int expectedID = 1;
                private string expectedName = "Test FunctionRole";
                private string expectedCategoryName = "Test Category";
                private string expectedSubcategoryName = "Test Subcategory";
                private string expectedMaskName = "Test Mask";
                private FunctionRole.ValidationType expectedValidationType = FunctionRole.ValidationType.DoesNotNeedValidation; 
                private FunctionRoleAttribute expectedFunctionRoleAttribute = new FunctionRoleAttribute();

                private FunctionRole functionRole;

                [SetUp]
                public void Init()
                {
                        this.expectedFunctionRoleAttribute.Category = new FunctionRole.Category();
                        this.expectedFunctionRoleAttribute.Category.Name = this.expectedCategoryName;
                        this.expectedFunctionRoleAttribute.Subcategory = new FunctionRole.Subcategory();
                        this.expectedFunctionRoleAttribute.Subcategory.Name = this.expectedSubcategoryName;
                        this.expectedFunctionRoleAttribute.Mask = new Mask();
                        this.expectedFunctionRoleAttribute.Mask.Name = this.expectedMaskName;

                        functionRole = new FunctionRole();
                        functionRole.ID = this.expectedID;
                        functionRole.Name = this.expectedName;
                        functionRole.Attributes.Add(this.expectedFunctionRoleAttribute.ToString(), this.expectedFunctionRoleAttribute);
                        functionRole.Validation = this.expectedValidationType;
                }
                [Test]
                public void GetDefaultValidation()
                {
                        // Test 
                        Assert.AreEqual(FunctionRole.ValidationType.NeedsValidation
                                , FunctionRole.DefaltValidation);
                }
                [Test]
                public void ValidationTypesDictionary_Count()
                {
                        // Preparation
                        int expectedCount = 3;
                        UserManagement userManagement = new UserManagement();

                        // Test 
                        Assert.AreEqual(expectedCount, FunctionRole.ValidationTypesDictionary.Count);
                }
                [Test]
                public void ValidationTypesDictionary_NeedsValidation()
                {
                        // Preparations
                        FunctionRole.ValidationType expectedType = FunctionRole.ValidationType.NeedsValidation;
                        int expectedID = 1;
                        string expectedVisibleName = "All data changes by this role need validation";
                        UserManagement userManagement = new UserManagement();

                        // Test
                        FunctionRole.ValidationTypeData validationType = FunctionRole.ValidationTypesDictionary[expectedType];

                        // Checks
                        Assert.AreEqual(expectedID, validationType.ID);
                        Assert.AreEqual(expectedType, validationType.Type);
                        Assert.AreEqual(expectedVisibleName, validationType.VisibleName);
                }
                [Test]
                public void ValidationTypesDictionary_Validates()
                {
                        // Preparations
                        FunctionRole.ValidationType expectedType = FunctionRole.ValidationType.Validates;
                        int expectedID = 2;
                        string expectedVisibleName = "This role validates data changes";
                        UserManagement userManagement = new UserManagement();

                        // Test
                        FunctionRole.ValidationTypeData validationType = FunctionRole.ValidationTypesDictionary[expectedType];

                        // Checks
                        Assert.AreEqual(expectedID, validationType.ID);
                        Assert.AreEqual(expectedType, validationType.Type);
                        Assert.AreEqual(expectedVisibleName, validationType.VisibleName);
                }
                [Test]
                public void ValidationTypesDictionary_DoesNotNeedValidation()
                {
                        // Preparations
                        FunctionRole.ValidationType expectedType = FunctionRole.ValidationType.DoesNotNeedValidation;
                        int expectedID = 3;
                        string expectedVisibleName = "This role doesn't need any validation";
                        UserManagement userManagement = new UserManagement();

                        // Test
                        FunctionRole.ValidationTypeData validationType = FunctionRole.ValidationTypesDictionary[expectedType];

                        // Checks
                        Assert.AreEqual(expectedID, validationType.ID);
                        Assert.AreEqual(expectedType, validationType.Type);
                        Assert.AreEqual(expectedVisibleName, validationType.VisibleName);
                }
                [Test]
                public void GetID()
                {
                        // Test 
                        Assert.AreEqual(this.expectedID, this.functionRole.ID);
                }
                [Test]
                public void GetName()
                {
                        // Test 
                        Assert.AreEqual(this.expectedName, this.functionRole.Name);
                }
                [Test]
                public void GetAttributes()
                {
                        // Test 
                        Assert.AreEqual(this.expectedFunctionRoleAttribute
                                , this.functionRole.Attributes[this.expectedFunctionRoleAttribute.ToString()]);
                }
                [Test]
                public void GetValidation()
                {
                        // Test 
                        Assert.AreEqual(this.expectedValidationType, this.functionRole.Validation);
                }
                [Test]
                public void GetValidationData()
                {
                        // Preparations
                        int expectedID = 3;
                        FunctionRole.ValidationType expectedType = FunctionRole.ValidationType.DoesNotNeedValidation;
                        string expectedVisibleName = "This role doesn't need any validation";
                        UserManagement userManagement = new UserManagement();

                        // Test
                        FunctionRole.ValidationTypeData validationTypeData = functionRole.ValidationData;

                        // Checks
                        Assert.AreEqual(expectedID, validationTypeData.ID);
                        Assert.AreEqual(expectedType, validationTypeData.Type);
                        Assert.AreEqual(expectedVisibleName, validationTypeData.VisibleName);
                }
                [Test]
                public void SetName()
                {
                        // Preparation
                        string expectedNewName = "New Test FunctionRole";

                        // Test 
                        this.functionRole.Name = expectedNewName;

                        // Check
                        Assert.AreEqual(expectedNewName, this.functionRole.Name);
                }
                [Test]
                public void SetValidation()
                {
                        // Preparation
                        FunctionRole.ValidationType expectedNewValidation = FunctionRole.ValidationType.Validates;

                        // Test 
                        this.functionRole.Validation = expectedNewValidation;

                        // Check 
                        Assert.AreEqual(expectedNewValidation, this.functionRole.Validation);
                }
                [Test]
                public void ContainsCategoryRestriction()
                {
                        bool returnStatus;

                        // Test
                        returnStatus = functionRole.ContainsCategoryRestriction(expectedCategoryName);

                        // Check
                        Assert.IsTrue(returnStatus, "ContainsCategoryRestriction return status error:");
                }
                [Test]
                public void ContainsSubcategoryRestriction()
                {
                        bool returnStatus;

                        // Test
                        returnStatus = functionRole.ContainsSubcategoryRestriction(expectedFunctionRoleAttribute.Category, expectedSubcategoryName);

                        // Check
                        Assert.IsTrue(returnStatus, "ContainsSubcategoryRestriction return status error:");
                }
                [Test]
                public void ContainsMaskRestriction()
                {
                        bool returnStatus;

                        // Test
                        returnStatus = functionRole.ContainsMaskRestriction(expectedFunctionRoleAttribute.Category
                                , expectedFunctionRoleAttribute.Subcategory
                                , expectedMaskName);

                        // Check
                        Assert.IsTrue(returnStatus, "ContainsMaskRestriction return status error:");
                }
                [Test]
                public void ValidateNewAttribute_AttributeExists()
                {
                        bool returnStatus;
                        string errorMessage = "";

                        // Test
                        returnStatus = functionRole.ValidateNewAttribute(this.expectedFunctionRoleAttribute, ref errorMessage);

                        // Check
                        Assert.IsFalse(returnStatus, "ValidateNewAttribute return status error:");
                        Assert.AreEqual(RAIS.Common.Messages.FUNCTION_ROLE_ATTRIBUTE_EXISTS, errorMessage);
                }
                [Test]
                public void ValidateNewAttribute_CategoryRestriction()
                {
                        bool returnStatus;
                        string errorMessage = "";
                        FunctionRoleAttribute newFunctionRoleAttribute = new FunctionRoleAttribute();
                        newFunctionRoleAttribute.Category = new FunctionRole.Category();
                        newFunctionRoleAttribute.Category.Name = RAIS.Common.Constants.ALL_CATEGORIES;
                        newFunctionRoleAttribute.Subcategory = new FunctionRole.Subcategory();
                        newFunctionRoleAttribute.Subcategory.Name = this.expectedSubcategoryName;
                        newFunctionRoleAttribute.Mask = new Mask();
                        newFunctionRoleAttribute.Mask.Name = this.expectedMaskName;

                        // Test
                        returnStatus = functionRole.ValidateNewAttribute(newFunctionRoleAttribute, ref errorMessage);

                        // Check
                        Assert.IsFalse(returnStatus, "ValidateNewAttribute return status error:");
                        Assert.AreEqual(RAIS.Common.Messages.FUNCTION_ROLE_ATTRIBUTE_CONFLICT, errorMessage);
                }
                [Test]
                public void ValidateNewAttribute_SubcategoryRestriction()
                {
                        bool returnStatus;
                        string errorMessage = "";
                        FunctionRoleAttribute newFunctionRoleAttribute = new FunctionRoleAttribute();
                        newFunctionRoleAttribute.Category = new FunctionRole.Category();
                        newFunctionRoleAttribute.Category.Name = this.expectedCategoryName;
                        newFunctionRoleAttribute.Subcategory = new FunctionRole.Subcategory();
                        newFunctionRoleAttribute.Subcategory.Name = RAIS.Common.Constants.ALL_SUBCATEGORIES;
                        newFunctionRoleAttribute.Mask = new Mask();
                        newFunctionRoleAttribute.Mask.Name = this.expectedMaskName;

                        // Test
                        returnStatus = functionRole.ValidateNewAttribute(newFunctionRoleAttribute, ref errorMessage);

                        // Check
                        Assert.IsFalse(returnStatus, "ValidateNewAttribute return status error:");
                        Assert.AreEqual(RAIS.Common.Messages.FUNCTION_ROLE_ATTRIBUTE_CONFLICT, errorMessage);
                }
                [Test]
                public void ValidateNewAttribute_MaskRestriction()
                {
                        bool returnStatus;
                        string errorMessage = "";
                        FunctionRoleAttribute newFunctionRoleAttribute = new FunctionRoleAttribute();
                        newFunctionRoleAttribute.Category = new FunctionRole.Category();
                        newFunctionRoleAttribute.Category.Name = this.expectedCategoryName;
                        newFunctionRoleAttribute.Subcategory = new FunctionRole.Subcategory();
                        newFunctionRoleAttribute.Subcategory.Name = this.expectedSubcategoryName;
                        newFunctionRoleAttribute.Mask = new Mask();
                        newFunctionRoleAttribute.Mask.Name = RAIS.Common.Constants.ALL_MASKS;

                        // Test
                        returnStatus = functionRole.ValidateNewAttribute(newFunctionRoleAttribute, ref errorMessage);

                        // Check
                        Assert.IsFalse(returnStatus, "ValidateNewAttribute return status error:");
                        Assert.AreEqual(RAIS.Common.Messages.FUNCTION_ROLE_ATTRIBUTE_CONFLICT, errorMessage);
                }
        }
}